import config from './config.js';

// 检测平台环境
const isWxMiniProgram = () => {
    // #ifdef MP-WEIXIN
    return true;
    // #endif
    return false;
};

// 确保wx.cloud已初始化（仅微信小程序环境）
const ensureCloudInit = () => {
    // #ifdef MP-WEIXIN
    if (!wx.cloud) {
        console.error('请使用 2.23.0 或以上的基础库以使用云能力');
        return false;
    }
    try {
        wx.cloud.init({
            env: config.cloudEnv || '', // 使用默认环境或指定的环境
            traceUser: true,
        });
        return true;
    } catch (e) {
        console.error('云服务初始化失败：', e);
        return false;
    }
    // #endif
    return false;
};

// 请求拦截器
const requestInterceptor = (options) => {
    // 统一添加access_token
    const access_token = uni.getStorageSync('access_token');
    if (access_token) {
        options.header = {
            ...options.header,
            'Authorization': `Bearer ${access_token}`
        };
    }
    
    // 处理请求URL
    if (!options.url.startsWith('http')) {
        // 确保 baseUrl 不以斜杠结尾，options.url 不以斜杠开头
        const baseUrl = config.baseUrl.endsWith('/') ? config.baseUrl.slice(0, -1) : config.baseUrl;
        const url = options.url.startsWith('/') ? options.url : '/' + options.url;
        options.url = baseUrl + url;
    }
    
    return options;
};

// 响应拦截器
const responseInterceptor = (response) => {
    const { statusCode, data } = response;
    
    // 请求成功
    if (statusCode >= 200 && statusCode < 300) {
        return data;
    }
    
    // 401: 未登录或access_token过期
    if (statusCode === 401) {
        uni.showToast({
            title: '请先登录',
            icon: 'none'
        });
        
        // 清除access_token并跳转到登录页
        uni.removeStorageSync('access_token');
        
        // 获取当前页面路径用于登录后跳回
        const pages = getCurrentPages();
        const currentPage = pages[pages.length - 1];
        const url = `/${currentPage.route}`;
        const redirect = encodeURIComponent(url);
        
        // 跳转到登录页
        uni.navigateTo({
            url: `/pages/user/login?redirect=${redirect}`
        });
        
        return Promise.reject(new Error('未登录或登录已过期'));
    }
    
    // 其他错误
    uni.showToast({
        title: data.message || '请求失败',
        icon: 'none'
    });
    
    return Promise.reject(data);
};

// 使用云托管服务发起请求（仅微信小程序环境）
const cloudRequest = (options) => {
    // 应用请求拦截器
    options = requestInterceptor(options);

    console.log("options")
    console.log(options)
    
    // 提取URL的路径部分，不使用URL构造函数（在小程序中不可用）
    let path = '';
    const url = options.url;
    
    // 如果URL包含http(s)://，提取域名后的部分
    if (url.includes('://')) {
        const urlParts = url.split('/');
        // 去掉协议和域名部分
        path = '/' + urlParts.slice(3).join('/');
    } else {
        // 已经是相对路径
        path = url.startsWith('/') ? url : '/' + url;
    }
    console.log("path")
    console.log(path)
    // 如果URL包含查询参数，确保它们被保留
    const queryIndex = path.indexOf('?');
    if (queryIndex !== -1) {
        // path已经包含查询参数，无需额外处理
    }

    console.log("request header: "+options.header)
    return new Promise((resolve, reject) => {
        // 确保已初始化云服务
        if (!ensureCloudInit()) {
            reject(new Error('云服务初始化失败'));
            return;
        }
        
        // 使用wx.cloud.callContainer进行调用
        wx.cloud.callContainer({
            config: {
                env: config.cloudEnv || '', // 云托管的环境ID
            },
            path: path, // 云托管服务路径
            method: options.method,
            data: options.data,
            header: 
            {
                ...options.header,
                'X-WX-SERVICE': 'flask-fnqs', // xxx中填入服务名称（微信云托管 - 服务管理 - 服务列表 - 服务名称）
            },
            success: (res) => {
                try {
                    // 打印callID便于调试跟踪
                    console.log(`微信云托管调用成功: callID: ${res.callID}`);
                    
                    // 处理响应
                    const processedRes = {
                        statusCode: res.statusCode,
                        data: res.data
                    };
                    
                    // 应用响应拦截器
                    const result = responseInterceptor(processedRes);
                    resolve(result);
                } catch (error) {
                    reject(error);
                }
            },
            fail: (err) => {
                console.error('微信云托管调用失败：', err);
                uni.showToast({
                    title: '网络异常，请稍后重试',
                    icon: 'none'
                });
                reject(err);
            }
        });
    });
};

// 封装请求方法
const request = (options) => {
    // 微信小程序环境，使用云托管服务
    /*
    */
    if (isWxMiniProgram()) {
        return cloudRequest(options);
    }
    
    // 其他环境，使用标准请求
    options = requestInterceptor(options);

    
    return new Promise((resolve, reject) => {
        uni.request({
            ...options,
            success: (res) => {
                try {
                    // 应用响应拦截器
                    const result = responseInterceptor(res);
                    resolve(result);
                } catch (error) {
                    reject(error);
                }
            },
            fail: (err) => {
                uni.showToast({
                    title: '网络异常，请稍后重试',
                    icon: 'none'
                });
                reject(err);
            }
        });
    });
};

// 封装常用请求方法
const http = {
    get(url, data = {}, options = {}) {
        return request({
            url,
            data,
            method: 'GET',
            ...options
        });
    },
    
    post(url, data = {}, options = {}) {
        return request({
            url,
            data,
            method: 'POST',
            ...options
        });
    },
    
    put(url, data = {}, options = {}) {
        return request({
            url,
            data,
            method: 'PUT',
            ...options
        });
    },
    
    delete(url, data = {}, options = {}) {
        return request({
            url,
            data,
            method: 'DELETE',
            ...options
        });
    },
    
    // 上传文件
    upload(url, filePath, formData = {}, options = {}) {
        // 微信小程序环境，使用云储存
        if (isWxMiniProgram() && config.useCloudStorage) {
            return new Promise((resolve, reject) => {
                if (!ensureCloudInit()) {
                    reject(new Error('云服务初始化失败'));
                    return;
                }
                
                const cloudPath = options.cloudPath || `upload/${Date.now()}_${Math.floor(Math.random()*1000)}${filePath.substring(filePath.lastIndexOf('.'))}`;
                
                wx.cloud.uploadFile({
                    cloudPath: cloudPath,
                    filePath: filePath,
                    success: res => {
                        // 返回文件ID等信息
                        resolve({
                            fileID: res.fileID,
                            statusCode: 200,
                            data: {
                                fileID: res.fileID,
                                url: res.fileID // 文件访问链接，可能需要通过getTempFileURL获取
                            }
                        });
                    },
                    fail: err => {
                        console.error('云存储上传失败：', err);
                        uni.showToast({
                            title: '上传失败，请稍后重试',
                            icon: 'none'
                        });
                        reject(err);
                    }
                });
            });
        }
        
        // 应用请求拦截器
        const interceptedOptions = requestInterceptor({
            url,
            header: options.header || {}
        });
        
        return new Promise((resolve, reject) => {
            uni.uploadFile({
                url: interceptedOptions.url,
                filePath,
                name: options.name || 'file',
                formData,
                header: interceptedOptions.header,
                success: (res) => {
                    try {
                        // 上传接口返回的是字符串，需要转换为对象
                        if (typeof res.data === 'string') {
                            res.data = JSON.parse(res.data);
                        }
                        
                        // 应用响应拦截器
                        const result = responseInterceptor(res);
                        resolve(result);
                    } catch (error) {
                        reject(error);
                    }
                },
                fail: (err) => {
                    uni.showToast({
                        title: '上传失败，请稍后重试',
                        icon: 'none'
                    });
                    reject(err);
                }
            });
        });
    }
};

export default http; 